home *** CD-ROM | disk | FTP | other *** search
/ Freelog 100 / FreelogNo100-NovembreDecembre2010.iso / Musique / solfege / solfege-win32-3.17.0.exe / {app} / bin / Lib / bsddb / test / test_recno.py < prev    next >
Text File  |  2007-12-10  |  8KB  |  296 lines
  1. """TestCases for exercising a Recno DB.
  2. """
  3.  
  4. import os
  5. import sys
  6. import errno
  7. import tempfile
  8. from pprint import pprint
  9. import unittest
  10.  
  11. from test_all import verbose
  12.  
  13. try:
  14.     # For Pythons w/distutils pybsddb
  15.     from bsddb3 import db
  16. except ImportError:
  17.     # For Python 2.3
  18.     from bsddb import db
  19.  
  20. letters = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
  21.  
  22.  
  23. #----------------------------------------------------------------------
  24.  
  25. class SimpleRecnoTestCase(unittest.TestCase):
  26.     def setUp(self):
  27.         self.filename = tempfile.mktemp()
  28.  
  29.     def tearDown(self):
  30.         try:
  31.             os.remove(self.filename)
  32.         except OSError, e:
  33.             if e.errno <> errno.EEXIST: raise
  34.  
  35.     def test01_basic(self):
  36.         d = db.DB()
  37.  
  38.         get_returns_none = d.set_get_returns_none(2)
  39.         d.set_get_returns_none(get_returns_none)
  40.  
  41.         d.open(self.filename, db.DB_RECNO, db.DB_CREATE)
  42.  
  43.         for x in letters:
  44.             recno = d.append(x * 60)
  45.             assert type(recno) == type(0)
  46.             assert recno >= 1
  47.             if verbose:
  48.                 print recno,
  49.  
  50.         if verbose: print
  51.  
  52.         stat = d.stat()
  53.         if verbose:
  54.             pprint(stat)
  55.  
  56.         for recno in range(1, len(d)+1):
  57.             data = d[recno]
  58.             if verbose:
  59.                 print data
  60.  
  61.             assert type(data) == type("")
  62.             assert data == d.get(recno)
  63.  
  64.         try:
  65.             data = d[0]  # This should raise a KeyError!?!?!
  66.         except db.DBInvalidArgError, val:
  67.             assert val[0] == db.EINVAL
  68.             if verbose: print val
  69.         else:
  70.             self.fail("expected exception")
  71.  
  72.         # test that has_key raises DB exceptions (fixed in pybsddb 4.3.2)
  73.         try:
  74.             d.has_key(0)
  75.         except db.DBError, val:
  76.             pass
  77.         else:
  78.             self.fail("has_key did not raise a proper exception")
  79.  
  80.         try:
  81.             data = d[100]
  82.         except KeyError:
  83.             pass
  84.         else:
  85.             self.fail("expected exception")
  86.  
  87.         try:
  88.             data = d.get(100)
  89.         except db.DBNotFoundError, val:
  90.             if get_returns_none:
  91.                 self.fail("unexpected exception")
  92.         else:
  93.             assert data == None
  94.  
  95.         keys = d.keys()
  96.         if verbose:
  97.             print keys
  98.         assert type(keys) == type([])
  99.         assert type(keys[0]) == type(123)
  100.         assert len(keys) == len(d)
  101.  
  102.         items = d.items()
  103.         if verbose:
  104.             pprint(items)
  105.         assert type(items) == type([])
  106.         assert type(items[0]) == type(())
  107.         assert len(items[0]) == 2
  108.         assert type(items[0][0]) == type(123)
  109.         assert type(items[0][1]) == type("")
  110.         assert len(items) == len(d)
  111.  
  112.         assert d.has_key(25)
  113.  
  114.         del d[25]
  115.         assert not d.has_key(25)
  116.  
  117.         d.delete(13)
  118.         assert not d.has_key(13)
  119.  
  120.         data = d.get_both(26, "z" * 60)
  121.         assert data == "z" * 60, 'was %r' % data
  122.         if verbose:
  123.             print data
  124.  
  125.         fd = d.fd()
  126.         if verbose:
  127.             print fd
  128.  
  129.         c = d.cursor()
  130.         rec = c.first()
  131.         while rec:
  132.             if verbose:
  133.                 print rec
  134.             rec = c.next()
  135.  
  136.         c.set(50)
  137.         rec = c.current()
  138.         if verbose:
  139.             print rec
  140.  
  141.         c.put(-1, "a replacement record", db.DB_CURRENT)
  142.  
  143.         c.set(50)
  144.         rec = c.current()
  145.         assert rec == (50, "a replacement record")
  146.         if verbose:
  147.             print rec
  148.  
  149.         rec = c.set_range(30)
  150.         if verbose:
  151.             print rec
  152.  
  153.         # test that non-existant key lookups work (and that
  154.         # DBC_set_range doesn't have a memleak under valgrind)
  155.         rec = c.set_range(999999)
  156.         assert rec == None
  157.         if verbose:
  158.             print rec
  159.  
  160.         c.close()
  161.         d.close()
  162.  
  163.         d = db.DB()
  164.         d.open(self.filename)
  165.         c = d.cursor()
  166.  
  167.         # put a record beyond the consecutive end of the recno's
  168.         d[100] = "way out there"
  169.         assert d[100] == "way out there"
  170.  
  171.         try:
  172.             data = d[99]
  173.         except KeyError:
  174.             pass
  175.         else:
  176.             self.fail("expected exception")
  177.  
  178.         try:
  179.             d.get(99)
  180.         except db.DBKeyEmptyError, val:
  181.             if get_returns_none:
  182.                 self.fail("unexpected DBKeyEmptyError exception")
  183.             else:
  184.                 assert val[0] == db.DB_KEYEMPTY
  185.                 if verbose: print val
  186.         else:
  187.             if not get_returns_none:
  188.                 self.fail("expected exception")
  189.  
  190.         rec = c.set(40)
  191.         while rec:
  192.             if verbose:
  193.                 print rec
  194.             rec = c.next()
  195.  
  196.         c.close()
  197.         d.close()
  198.  
  199.     def test02_WithSource(self):
  200.         """
  201.         A Recno file that is given a "backing source file" is essentially a
  202.         simple ASCII file.  Normally each record is delimited by \n and so is
  203.         just a line in the file, but you can set a different record delimiter
  204.         if needed.
  205.         """
  206.         homeDir = os.path.join(tempfile.gettempdir(), 'db_home')
  207.         source = os.path.join(homeDir, 'test_recno.txt')
  208.         if not os.path.isdir(homeDir):
  209.             os.mkdir(homeDir)
  210.         f = open(source, 'w') # create the file
  211.         f.close()
  212.  
  213.         d = db.DB()
  214.         # This is the default value, just checking if both int
  215.         d.set_re_delim(0x0A)
  216.         d.set_re_delim('\n')  # and char can be used...
  217.         d.set_re_source(source)
  218.         d.open(self.filename, db.DB_RECNO, db.DB_CREATE)
  219.  
  220.         data = "The quick brown fox jumped over the lazy dog".split()
  221.         for datum in data:
  222.             d.append(datum)
  223.         d.sync()
  224.         d.close()
  225.  
  226.         # get the text from the backing source
  227.         text = open(source, 'r').read()
  228.         text = text.strip()
  229.         if verbose:
  230.             print text
  231.             print data
  232.             print text.split('\n')
  233.  
  234.         assert text.split('\n') == data
  235.  
  236.         # open as a DB again
  237.         d = db.DB()
  238.         d.set_re_source(source)
  239.         d.open(self.filename, db.DB_RECNO)
  240.  
  241.         d[3] = 'reddish-brown'
  242.         d[8] = 'comatose'
  243.  
  244.         d.sync()
  245.         d.close()
  246.  
  247.         text = open(source, 'r').read()
  248.         text = text.strip()
  249.         if verbose:
  250.             print text
  251.             print text.split('\n')
  252.  
  253.         assert text.split('\n') == \
  254.              "The quick reddish-brown fox jumped over the comatose dog".split()
  255.  
  256.     def test03_FixedLength(self):
  257.         d = db.DB()
  258.         d.set_re_len(40)  # fixed length records, 40 bytes long
  259.         d.set_re_pad('-') # sets the pad character...
  260.         d.set_re_pad(45)  # ...test both int and char
  261.         d.open(self.filename, db.DB_RECNO, db.DB_CREATE)
  262.  
  263.         for x in letters:
  264.             d.append(x * 35)    # These will be padded
  265.  
  266.         d.append('.' * 40)      # this one will be exact
  267.  
  268.         try:                    # this one will fail
  269.             d.append('bad' * 20)
  270.         except db.DBInvalidArgError, val:
  271.             assert val[0] == db.EINVAL
  272.             if verbose: print val
  273.         else:
  274.             self.fail("expected exception")
  275.  
  276.         c = d.cursor()
  277.         rec = c.first()
  278.         while rec:
  279.             if verbose:
  280.                 print rec
  281.             rec = c.next()
  282.  
  283.         c.close()
  284.         d.close()
  285.  
  286.  
  287. #----------------------------------------------------------------------
  288.  
  289.  
  290. def test_suite():
  291.     return unittest.makeSuite(SimpleRecnoTestCase)
  292.  
  293.  
  294. if __name__ == '__main__':
  295.     unittest.main(defaultTest='test_suite')
  296.